home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / common / spelling / dicts.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  9.6 KB  |  299 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement, division
  5. from util import soupify, urlcacheopen, httpjoin, autoassign, httpok
  6. from path import path
  7. import subprocess
  8. import tarfile
  9. import shlex
  10. import logging
  11. log = logging.getLogger('spellchecker')
  12.  
  13. class AspellDictionary(object):
  14.     
  15.     def __init__(self, id, name_english, name_native):
  16.         autoassign(self, locals())
  17.  
  18.     
  19.     def __repr__(self):
  20.         return '<%s id=%s name=%s(%r)>' % (type(self).__name__, self.id, self.name_english, self.name_native)
  21.  
  22.     
  23.     def name_description(self):
  24.         return self.name_english
  25.  
  26.     name_description = property(name_description)
  27.  
  28.  
  29. class RemoteAspellDictionary(AspellDictionary):
  30.     ROOT = 'http://ftp.gnu.org/gnu/aspell/dict/'
  31.     
  32.     def __init__(self, id, n_e, n_n, dict_dir, dict_path):
  33.         AspellDictionary.__init__(self, id, n_e, n_n)
  34.         self.directory = dict_dir
  35.         self.package_path = dict_path
  36.         self.digest_location = dict_path + '.sig'
  37.         self.sig = None
  38.         self.needs_update = True
  39.  
  40.     
  41.     def fetch_sig(self, root = None):
  42.         if self.sig is None:
  43.             (response, content) = urlcacheopen(self.get_digest_location(root))
  44.             if not response.ok:
  45.                 return False
  46.             
  47.             self.sig = content
  48.             self.needs_update = not (response.fromcache)
  49.         
  50.         return True
  51.  
  52.     
  53.     def clear_sig(self, root = None):
  54.         pass
  55.  
  56.     
  57.     def get_package_path(self, root = None):
  58.         if not root:
  59.             pass
  60.         return httpjoin(self.ROOT, self.package_path)
  61.  
  62.     
  63.     def get_digest_location(self, root = None):
  64.         return self.get_package_path(root) + '.sig'
  65.  
  66.     
  67.     def get_directory(self, root = None):
  68.         if not root:
  69.             pass
  70.         return httpjoin(self.ROOT, self.directory)
  71.  
  72.     
  73.     def __repr__(self):
  74.         return AspellDictionary.__repr__(self)[:-1] + ' url=%s>' % self.package_path
  75.  
  76.  
  77.  
  78. class LocalAspellDictionary(AspellDictionary):
  79.     
  80.     def __init__(self, id, n_e, n_n, signame):
  81.         AspellDictionary(self, id, n_e, n_n)
  82.         self.signame = signame
  83.  
  84.  
  85.  
  86. def AspellIndexToYaml(root = None, outfile = None):
  87.     import syck
  88.     index = _GetAspellIndex(root)
  89.     mydict = { }
  90.     
  91.     def RAD_to_dict(rad):
  92.         res = { }
  93.         if rad.name_native is not None:
  94.             res.update(name_native = rad.name_native.encode('utf-8'))
  95.         
  96.         res.update(name_english = rad.name_english.encode('utf-8'), location = rad.package_path.encode('utf-8'))
  97.         return res
  98.  
  99.     for d in index:
  100.         mydict[d.id.encode('utf-8')] = RAD_to_dict(d)
  101.     
  102.     return syck.dump(mydict, outfile)
  103.  
  104.  
  105. def _GetAspellIndex(root = None):
  106.     RAD = RemoteAspellDictionary
  107.     if not root:
  108.         pass
  109.     (response, content) = urlcacheopen(httpjoin(RAD.ROOT, '0index.html'), decode = False)
  110.     if not response.ok:
  111.         print 'Unhandled HTTP response code: %r' % response
  112.         return ()
  113.     
  114.     soup = soupify(content)
  115.     results = { }
  116.     for row in soup.find('a', attrs = dict(name = '0.50')).findAllNext('tr'):
  117.         contents = row.findAll('td')
  118.         if len(contents) == 4:
  119.             (id, name_english, name_native, dictionary_path) = contents
  120.             id = id.find(href = True)
  121.             if id is None:
  122.                 continue
  123.             
  124.             id = id['href']
  125.             if id not in results:
  126.                 dictionary_path = dictionary_path.find(href = True)
  127.                 if dictionary_path is None:
  128.                     continue
  129.                 
  130.                 dictionary_path = dictionary_path['href']
  131.                 name_english = name_english.renderContents(None).decode('xml')
  132.                 if not name_native.renderContents(None).decode('xml').strip():
  133.                     pass
  134.                 name_native = None
  135.                 results[id] = RAD(id, name_english, name_native, id, dictionary_path)
  136.             
  137.         id not in results
  138.     
  139.     return results.values()
  140.  
  141.  
  142. def DownloadAllDictionaries(infodict, towhere, root = None):
  143.     if root is None:
  144.         root = RemoteAspellDictionary.ROOT
  145.     
  146.     for id in infodict:
  147.         name = infodict[id]['name_english']
  148.         bz2path = infodict[id]['location']
  149.         localpath = path(towhere) / bz2path
  150.         bz2path = httpjoin(root, bz2path)
  151.         localpath = localpath.expand()
  152.         print 'Downloading %s (%s) from %s to %s... ' % (name, id, bz2path, localpath),
  153.         (response, content) = urlcacheopen(bz2path)
  154.         print response.reason
  155.         if response.ok:
  156.             if not localpath.parent.exists():
  157.                 localpath.parent.makedirs()
  158.             
  159.             
  160.             try:
  161.                 f = _[2]
  162.                 f.write(content)
  163.             finally:
  164.                 pass
  165.  
  166.             continue
  167.         open(localpath, 'wb')
  168.     
  169.  
  170.  
  171. def ExtractInfoFiles(localroot):
  172.     localroot = path(localroot)
  173.     for bz2path in localroot.walkfiles('*.tar.bz2'):
  174.         tar = None
  175.         infofile = None
  176.         
  177.         try:
  178.             tar = tarfile.open(bz2path, 'r:bz2')
  179.             for member in tar.getmembers():
  180.                 mempth = path(member.name)
  181.                 if mempth.name == 'info':
  182.                     break
  183.                     continue
  184.             else:
  185.                 print 'Couldn\'t get "info" from %s' % bz2path
  186.                 continue
  187.             infofile = tar.extractfile(member)
  188.             
  189.             try:
  190.                 f = _[2]
  191.                 f.write(infofile.read())
  192.             finally:
  193.                 pass
  194.  
  195.         finally:
  196.             if tar is not None:
  197.                 tar.close()
  198.             
  199.             if infofile is not None:
  200.                 infofile.close()
  201.             
  202.  
  203.     
  204.  
  205.  
  206. class AspellInfoShlexer(shlex.shlex):
  207.     
  208.     def __init__(self, *a, **k):
  209.         if 'posix' not in k:
  210.             k['posix'] = True
  211.         
  212.         shlex.shlex.__init__(self, *a, **k)
  213.         self.whitespace_split = True
  214.  
  215.     
  216.     def get_token(self):
  217.         curlineno = self.lineno
  218.         token = shlex.shlex.get_token(self)
  219.         if self.lineno != curlineno:
  220.             self.pushback.append('\n')
  221.         
  222.         return token
  223.  
  224.  
  225.  
  226. def GetAliases(root, id):
  227.     aliases = []
  228.     root = path(root)
  229.     
  230.     try:
  231.         info = _[2]
  232.         for line in info:
  233.             line = line.rstrip()
  234.             if line.startswith('alias'):
  235.                 (_alias, rest) = line.split(None, 1)
  236.                 rest = rest.split()
  237.                 alias_id = rest[0]
  238.                 alias_names = rest[1:]
  239.                 if alias_id != id:
  240.                     aliases.append((alias_id, alias_names))
  241.                 
  242.             alias_id != id
  243.     finally:
  244.         pass
  245.  
  246.     return aliases
  247.  
  248.  
  249. def GetAllAliases(root):
  250.     root = path(root)
  251.     aliases = { }
  252.     for lang in root.walkdirs():
  253.         lang = lang.name
  254.         aliases = GetAliases(root, lang)
  255.         if aliases:
  256.             print lang, aliases
  257.             continue
  258.     
  259.     return aliases
  260.  
  261.  
  262. def _getshlexer(fpath):
  263.     f = open(fpath, 'rb')
  264.     return AspellInfoShlexer(f)
  265.  
  266.  
  267. def MakeDigsbyDict(lang = 'en', local_dir = None):
  268.     digsby_words = set(('asap', 'asl', 'bbs', 'bff', 'brb', 'btw', 'cya', 'digsby', 'fud', 'fwiw', 'gl', 'ic', 'ily', 'im', 'imho', 'irl', 'jk', 'lmao', 'lol', 'np', 'oic', 'omg', 'plz', 'rofl', 'roflmao', 'thx', 'ttyl', 'ttys', 'u', 'wtf'))
  269.     dict_file = local_dir / ('digsby-%s.rws' % lang)
  270.     cmd = ' '.join([
  271.         '.\\lib\\aspell\\bin\\aspell.exe',
  272.         '--local-data-dir=%s' % subprocess.list2cmdline([
  273.             local_dir]),
  274.         '--lang=%s' % lang,
  275.         'create',
  276.         'master',
  277.         '"%s"' % dict_file])
  278.     startupinfo = subprocess.STARTUPINFO()
  279.     startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
  280.     startupinfo.wShowWindow = subprocess.SW_HIDE
  281.     Popen = Popen
  282.     PIPE = PIPE
  283.     import subprocess
  284.     proc = Popen(cmd.encode('filesys'), stdout = PIPE, stderr = PIPE, stdin = PIPE, startupinfo = startupinfo)
  285.     log.info('Creating Digsby dict in "%s"', lang)
  286.     log.info('Executing Command: %s', cmd)
  287.     result = proc.communicate('\n'.join(digsby_words))
  288.     log.info('Subprocess returned: %s', result)
  289.     return dict_file
  290.  
  291.  
  292. def _main(*a, **k):
  293.     MakeDigsbyDict(*a, **k)
  294.  
  295. if __name__ == '__main__':
  296.     import sys
  297.     _main(sys.argv[1:])
  298.  
  299.